﻿#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
//int main()
//{
//	//int b = 10;
//	//int  a = 10;
//
//	//int* pa;
//	//*pa = 10;
//	//a = 20;
//	//int* pa=&a;
//	//*pa = 20;
//	//const int* pa = &a;
//	//*pa = 20;
//	//pa = &b;
//	//int const* const pa = &a;
//	//*pa = 20;
//	//pa = &b;
//	printf("%d", a);
//}

//int main()
//{
//	int arr[5] = { 1,2,3,4,5 };
//	int* pa = arr;
//	for (int i = 0; i <= 5; i++)
//	{
//		printf("%d ", pa[i]);
//	}
//}
//#define NDEBUG
#include<assert.h>
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int* p = &arr[0];
//	//int i = 0;
//	p = NULL;
//	assert(p != NULL);//使用前判断
//	return 0;
//}

//int my_strlen(const char* str)
//{
//	int count = 0;
//	assert(str);
//	while (*str)
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//int main()
//{
//	int len = my_strlen("abcde");
//	printf("%d ", len);
//}
////
//#include <stdio.h>
//void Swap2(int* px, int* py)
//{
//	int tmp = 0;
//	tmp = *px;
//	*px = *py;
//	*py = tmp;
//}
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	printf("交换前：a=%d b=%d\n", a, b);
//	Swap2(&a, &b);
//	printf("交换后：a=%d b=%d\n", a, b);
//	return 0;
//}

//int main()
//{
//	int arr[2][5] = { {1,2,3,4,5} ,{6,7,8,9,10} };
//	int* ptr2 = *(arr + 1)+1;
//	printf("%d ", *(ptr2 - 1));
//	return 0;
//}
//
//int main()
//{
//	int a = 0;
//	printf("%zd ", sizeof(a));
//	printf("%zd ", sizeof(int));
//	printf("%zd ", sizeof a);
//
//	return 0;
//
//}

//int main()
//{
//	char arr1[] = "abc";
//	char arr2[] = { 'a','b','c' };
//
//	printf("%zd\n", sizeof(arr1));
//	printf("%zd\n", sizeof(arr2));
//
//	printf("%d\n", strlen(arr1));
//	printf("%d\n", strlen(arr2));
//
//
//	return 0;
//}

//int main()
//{
//	int a[] = { 1,2,3,4 };
//	//数组名单独放在sizeof或者&数组名的时候表示的是整个数组，其余情况都是首元素地址
//	//这里面a就是整个数组，因此所占字节大小就是4*4=16
//	printf("%zd\n", sizeof(a));//16
//	//这里不是单独放的，所以a是首元素地址，a+0还是地址，在64位环境下，它的值是8
//	printf("%zd\n", sizeof(a + 0));//8
//	//*a也就是首元素，类型为int
//	printf("%zd\n", sizeof(*a));//4
//	//首元素地址+1还是地址
//	printf("%zd\n", sizeof(a + 1));//8
//	//a[1]=*(a+1),也就是数组第二个元素
//	printf("%zd\n", sizeof(a[1])); //4
//	//&数组名表示整个数组地址，虽然它的类型是int(* )[4],但，是地址大小就是4/8
//	printf("%zd\n", sizeof(&a));//8
//	//*&a=a,表示整个数组地址
//	printf("%zd\n", sizeof(*&a));//16
//	//&a+1跳过整个数组，实际上还是地址
//	printf("%zd\n", sizeof(&a + 1));//8
//	return 0;
//}

//int main()
//{
//	char arr[] = { 'a','b','c','d','e','f' };
//	//arr表示首元素地址,所以strlen从arr[0]，开始向后统计到\0为止，但是arr里面没有\0，因此是随机值
//	printf("%zd\n", strlen(arr));
//	//首元素地址+0，还是首元素地址，因此还是随机值
//	printf("%zd\n", strlen(arr + 0));
//	//*arr,也就是拿到了首元素，strlen的参数是const char*，因此a->97，转换成地址传给strlen会出现非法访问-err
//	printf("%zd\n", strlen(*arr));
//	//arr[1]表示第二个元素，同上也是err
//	printf("%zd\n", strlen(arr[1]));
//	//&arr取出的是整个数组的地址，传给strlen，从首元素开始访问，结果还是随机值
//	printf("%zd\n", strlen(&arr));
//	//&arr+1,跳过整个数组，但还是地址，从'f'后面的地址开始访问，\0不知道在哪，所以还是随机值
//	printf("%zd\n", strlen(&arr + 1));
//	//&arr[0]=&*(arr+0),表示的还是首元素地址+1表示第二个元素地址，同上也是随机值
//	printf("%zd\n", strlen(&arr[0] + 1));
//	return 0;
//}

//int main()
//{
//	char arr[] = { 'a','b','c','d','e','f' };
//	//arr单独放在sizeof里面，表示的是整个数组，因此其计算结果为数组所占字节数
//	printf("%d\n", sizeof(arr));//6
//	//arr+0表示首元素地址
//	printf("%d\n", sizeof(arr + 0));//8
//	//*arr表示首元素
//	printf("%d\n", sizeof(*arr));//1
//	//arr[1]表示第二个元素
//	printf("%d\n", sizeof(arr[1]));//1
//	//&arr表示整个数组的地址，是地址，就占4/8
//	printf("%d\n", sizeof(&arr));//8
//	//&arr+1跳过整个数组，但还是地址
//	printf("%d\n", sizeof(&arr + 1));//8
//	//&arr[0]+1表示首元素地址+1，也就是第二个元素地址，还是地址
//	printf("%d\n", sizeof(&arr[0] + 1));//8
//	return 0;
//}

//int main()
//{
//	char arr[] = "abcdef";
//	//arr单独放在sizeof里面，表示整个数组，但这里面有个\0，因此结果为7*1=7
//	printf("%zd\n", sizeof(arr));//7
//	//arr+0,表示首元素地址
//	printf("%zd\n", sizeof(arr + 0));//8
//	//*arr表示首元素
//	printf("%zd\n", sizeof(*arr));//1
//	//arr[1]表示第二个元素
//	printf("%zd\n", sizeof(arr[1]));//1
//	//&arr取出的是整个数组的地址，但，老样子是地址，地址就是4/8
//	printf("%zd\n", sizeof(&arr));//8
//	//&arr+1跳过整个数组，但是地址4/8
//	printf("%zd\n", sizeof(&arr + 1));//8
//	//&arr[0]+1,表示第二个元素地址
//	printf("%zd\n", sizeof(&arr[0] + 1));//8
//	return 0;
//}


//int main()
//{
//	char arr[] = "abcdef";
//	//arr单独sizeof，整个数组，这里面有\0，因此结果为6
//	printf("%d\n", strlen(arr));//6
//	//arr+0，表示首元素地址
//	printf("%d\n", strlen(arr + 0));//6
//	//&arr取出整个数组的地址
//	printf("%d\n", strlen(&arr));//6
//	//&arr+1，跳过整个数组，随机值
//	printf("%d\n", strlen(&arr + 1));//随机值
//	//&arr[0]+1,表示第二个元素地址
//	printf("%d\n", strlen(&arr[0] + 1));//5
//	//*arr表示首元素
//	printf("%d\n", strlen(*arr));//err
//	//arr[1]表示第二个元素
//	printf("%d\n", strlen(arr[1]));//err
//	return 0;
//}
//
//int main()
//{
//	char* p = "abcdef";
//	//p为指针变量，指向的是'a'的地址
//	//sizeof(指针变量)=4/8
//	printf("%zd\n", sizeof(p));//8
//	//p+1表示第二个元素地址
//	printf("%zd\n", sizeof(p + 1));//8
//	//*p表示首元素
//	printf("%zd\n", sizeof(*p));//1
//	//p[0]表示*(p+0)，首元素
//	printf("%zd\n", sizeof(p[0]));//1
//	//&p表示首元素地址的地址
//	printf("%zd\n", sizeof(&p));//8
//	//&p+1,首元素地址的地址+1
//	printf("%zd\n", sizeof(&p + 1));//8
//	//&p[0]+1表示首元素地址+1
//	printf("%zd\n", sizeof(&p[0] + 1));//8
//	return 0;
//}

//int main()
//{
//	char* p = "abcdef";
//	//p->首元素地址
//	printf("%d\n", strlen(p));//6
//	//p+1第二个元素地址
//	printf("%d\n", strlen(p + 1));//5
//	//&p为首元素地址的地址
//	printf("%d\n", strlen(&p));//随机值
//	//&p为首元素地址的地址+1
//	printf("%d\n", strlen(&p + 1));//随机值
//	//首元素地址+1
//	printf("%d\n", strlen(&p[0] + 1));//5
//	//*p表示首元素
//	printf("%d\n", strlen(*p));//err
//	//同理，首元素
//	printf("%d\n", strlen(p[0]));//err
//	return 0;
//}

//int main()
//{
//	int a[3][4] = { 0 };
//	//a放sizeof里面，整个数组3*4*4=48
//	printf("%zd\n", sizeof(a));//48
//	//a[0][0]，表示第一行的首元素
//	printf("%zd\n", sizeof(a[0][0]));//4
//	//arr[0]是第一行的数组名,单独放在sizeof里面表示第一行，计算的是第一行的大小
//	printf("%zd\n", sizeof(a[0]));//4*4=16
//	//arr[0]没单独放，表示第一行首元素地址，+1为，一行第二个元素地址
//	printf("%zd\n", sizeof(a[0] + 1));//8
//	//arr[0]+1为第二个元素地址，解引用为第二个元素
//	printf("%zd\n", sizeof(*(a[0] + 1)));//4
//	//a在这表示表示首元素地址，也就是第一行地址，+1，为第二行地址
//	printf("%zd\n", sizeof(a + 1));//8
//	//*(a+1)表示第二行
//	printf("%zd\n", sizeof(*(a + 1)));//16
//	//&a[0]第一行的地址，+1，为第二行的地址
//	printf("%zd\n", sizeof(&a[0] + 1));//8
//	//&a[0]，取出的是整个第一行的地址+1，为第二行地址，解引用为第二行
//	printf("%zd\n", sizeof(*(&a[0] + 1)));//16
//	//*a表示第一行
//	printf("%zd\n", sizeof(*a));//16
//	//a[3]=*(a+3)，拿到的是第四行的地址，虽然a并没有第四行，但是前面我们说sizeof并不会真正访问，因此不会报错
//	printf("%zd\n", sizeof(a[3]));//16
//	return 0;
//}
//
//#include <stdio.h>
//int main()
//{
//	int a[5] = { 1, 2, 3, 4, 5 };
//	int* ptr = (int*)(&a + 1);
//	printf("%d,%d", *(a + 1), *(ptr - 1));//2,5
//	return 0;
//}


////在X86环境下
////假设结构体的⼤⼩是20个字节
////程序输出的结果是啥？
//struct Test
//{
//	int Num;
//	char* pcName;
//	short sDate;
//	char cha[2];
//	short sBa[4];
//}*p = (struct Test*)0x100000;//*p表示一个结构体指针，0x100000为一个整数，将它强转成结构体指针给到p
//int main()
//{
//	printf("%p\n", p + 0x1);
//	printf("%p\n", (unsigned long)p + 0x1);
//	printf("%p\n", (unsigned int*)p + 0x1);
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	int a[3][2] = { (0, 1), (2, 3), (4, 5) };//注意逗号表达式的结果是最后一个表达式的值！！！
//	int* p;
//	p = a[0];
//	printf("%d", p[0]);//第一个元素就是1
//	return 0;
//}



////假设环境是x86环境，程序输出的结果是啥？
//#include <stdio.h>
//int main()
//{
//	int a[5][5];
//	int(*p)[4];//p为一个数组指针，只不过他的类型并不是int(*)[5][5],意味着它+1只会往后跳4个字节！！！！
//	p = a;//把首元素地址给到了p
//	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
//	return 0;
//}




//#include <stdio.h>
//int main()
//{
//	char* a[] = { "work","at","alibaba" };
//	char** pa = a;
//	pa++;
//	printf("%s\n", *pa);
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//	int* ptr1 = (int*)(&aa + 1);
//	int* ptr2 = (int*)(*(aa + 1));
//	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	char* c[] = { "ENTER","NEW","POINT","FIRST" };
//	char** cp[] = { c + 3,c + 2,c + 1,c };
//	char*** cpp = cp;
//	printf("%s\n", **++cpp);//++cpp会真的是cpp往后移动！！！！
//	printf("%s\n", *-- * ++cpp + 3);
//	printf("%s\n", *cpp[-2] + 3);
//	printf("%s\n", cpp[-1][-1] + 1);
//	return 0;
//}
//int my_strlen(char* str)
//{
//	char* begin = str;
//	while (*str)
//	{
//		str++;
//	}
//	return str - begin;
//}
//int main()
//{
//	char arr[] = "abcdef";
//	int len = my_strlen(arr);
//	printf("%d", len);
//	return 0;
/*
char* my_strcpy(char* str1, const char* str2)
{
	char* ret = str1;
	assert(str1 != NULL );
	while (*str1)
	{
		str1++;
	}
	while (*str1++ = *str2++)
	{
		
	}
	return ret;
}
int main()
{
	char arr1[50] = "abcdef";
	char arr2[] = "hijk";
	printf("%s\n", my_strcpy(arr1, arr2));
	return 0;
}*/

//int my_strcmp(const char* str1, const char* str2)
//{
//	assert(str1 != NULL);
//	assert(str2 != NULL);
//
//	while (*str1 == *str2)
//	{
//		if (*str1 == '\0')
//		{
//			return 0;
//		}
//		str1++;
//		str2++;
//	}
//	return *str1 - *str2;
//}
//int main()
//{
//	char arr1[] = "abc";
//	char arr2[] = "abc";
//	char arr3[] = "abcde";
//	int ret=my_strcmp(arr1,arr2);
//	int ret2 = my_strcmp(arr3, arr2);
//
//	printf("%d %d", ret,ret2);
//	return 0;
//}

//char* my_strcat(char* str1, const char* str2)
//{
//	char* ret = str1;
//	assert(str1 != NULL);
//	assert(str2 != NULL);
//	while (*str1 != '\0')
//	{
//		str1++;
//	}
//	while (*str1++ = *str2++)
//	{
//		;
//	}
//	return ret;
//}
//int main()
//{
//	char arr1[50] = "abcd";
//	char arr2[] = "efj";
//	printf("%s\n",my_strcat(arr1, arr2));
//	return 0;
//}

//char* my_strstr(const char* str1, const char* str2)
//{
//	assert(str1 != NULL);
//	assert(str2 != NULL);
//	char* cur = (char*)str1;
//	if (*str2 == '\0')
//	{
//		return cur;
//	}
//	while (*cur)
//	{
//		char* s1 = cur;
//		char* s2 = (char*)str2;
//		while (*s1 && *s2 && *s1 == *s2)
//		{
//			s1++;
//			s2++;
//		}
//		if (*s2 == '\0')
//			return cur;
//		cur++;
//	}
//	return NULL;
//}
//int main()
//{
//	char arr1[] = "abbbcde";
//	char arr2[] = "bbc";
//	char arr3[] = "";
//	printf("%s\n",my_strstr(arr1,arr2));
//	printf("%s\n", my_strstr(arr2, arr3));
//
//	return 0;
//}

//#include<ctype.h>
//int main()
//{
//	char n = 0;
//	while (scanf("%c", &n) != EOF)
//	{
//		if (islower(n))
//		{
//			printf("%c",toupper(n));
//		}
//		else if (isupper)
//		{
//			printf("%c",tolower(n));
//		}
//	}
//	return 0;
//}
//#include<ctype.h>
//int main()
//{
//	int i = 0;
//	char arr[20] = "l like bite.\n";
//	while (arr[i])
//	{
//		if (islower(arr[i]))
//		{
//			arr[i]=toupper(arr[i]);
//		}
//		i++;
//	}
//	printf("%s\n", arr);
//	return 0;
//}

//#include<string.h>
//int main()
//{
//	const char* str1 = "abcdef";
//	const char* str2 = "bbb";
//	if (strlen(str2) - strlen(str1) > 0)
//	{
//		printf("str2>str1\n");
//	}
//	else
//	{
//		printf("srt1>str2\n");
//	}
//	return 0;
//}

//int my_strlen(const char* str)
//{
//	if (*str!='\0')
//	{
//		return 1 + my_strlen(str + 1);
//	}
//	else
//	{
//		return 0;
//	}
//}
//int main()
//{
//	char arr[] = "abcedf";
//	printf("%d", my_strlen(arr));
//	return 0;
//}
//#include<string.h>
//int main()
//{
//	char arr1[20] = "abcdefg";
//	char arr2[] = "cdef";
//	printf("%s\n",strcpy(arr1, arr2));
//	return 0;
//
//}

//char* my_strcpy(char* dest, const char* src)
//{
//	char* begin = dest;
//	while (*dest++=*src++)
//	{
//		;
//	}
//
//	return begin;
//}
//int main()
//{
//	char arr1[20] = "l am a shuaib";
//	char arr2[] = "l like you";
//	printf("%s\n",my_strcpy(arr1, arr2));
//	return 0;
//}

//char* my_strcay(char* str1, const char* str2)
//{
//	char* begin = str1;
//	while (*str1)
//	{
//		str1++;
//	}
//	while (*str1++ = *str2++)
//	{
//		;
//	}
//	return begin;
//}
//int main()
//{
//	char arr1[20] = "abcde";
//	char arr2[] = "fgjkh";
//	printf("%s\n", my_strcay(arr1, arr1));
//	return 0;
//}

//int my_strcmp(const char* str1, const char* str2)
//{
//	while (*str1 == *str2)
//	{
//		if (*str1 == '\0')
//		{
//			return 0;
//		}
//		str1++;
//		str2++;
//	}
//	return *str1 - *str2;
//}
//
//int main()
//{
//	char arr1[] = "abg";
//	char arr2[] = "abg";
//	char arr3[] = "abcde";
//	printf("%d ", my_strcmp(arr1, arr2));
//	printf("%d ", my_strcmp(arr2, arr3));
//
//	return 0;
//}
//#include<string.h>
//char* my_strstr(const char* str1, const char* str2)
//{
//	char* cur = (char*)str1;
//	char *s1, *s2;
//	if (!*str2 )
//	{
//		return cur;
//	}
//	while (*cur)
//	{
//		s1 = cur;
//		s2 = (char*)str2;
//		while (*s1 && *s2 && *s1 == *s2)
//		{
//			s1++;
//			s2++;
//		}
//		cur++;
//		if (!*s2)
//		{
//			return cur;
//		}
//	}
//	return NULL;
//
//}
//int main()
//{
//	char arr1[] = "This is a c program";
//	char arr2[] = "a c program";
//	printf("%s\n", my_strstr(arr1, arr2));
//	return 0;
//}
//int main()
//{
//	char arr1[] = "abcd";
//	char arr2[] = "abe";
//	int r1 = strncmp(arr1, arr2, 2);
//	int r2 = strncmp(arr1, arr2, 3);
//
//	printf("%d ", r1);
//	printf("%d ", r2);
//
//	return 0;
//}
//int main()
//{
//	char arr1[20] = "he he ";
//	char arr2[] = "hei hie";
//	printf("%s\n", strncat(arr1, arr2, 30));
//	return 0;
//}


//int main()
//{
//	int flag = 0;
//	int key = 0;
//	scanf("%d", &key);
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int j = 0;
//	for (j = 0; j < 10; j++)
//	{
//		if (key == arr[j])
//		{
//			flag = 1;
//			printf("Found! position is %d\n", j+1);
//		}
//		}
//	if (flag == 0)
//	{
//		printf("%d Not found!", key);
//	}
//
//	return 0;
//}
//void print(int arr[], int sz)
//{
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	printf("\n");
//}
//void bubble_sort(int arr[], int sz)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < sz - 1; i++)
//	{
//		int flag = 1;
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//				flag = 0;
//			}
//		}
//		if (flag == 1)
//			break;
//	}
//}
//int binary_search(int arr[], int sz,int key)
//{
//	int left = 0;
//	int right = sz - 1;
//	while (left <= right)
//	{
//		int mid = (left + right) / 2;
//		if (arr[mid] > key)
//		{
//			right = mid - 1;
//		}
//		else if (arr[mid] < key)
//		{
//			left = mid + 1;
//		}
//		else
//		{
//			return mid;
//		}
//	}
//	return -1;
//}
//int main()
//{
//	int key = 0;
//	int arr[10];
//	for (int i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	bubble_sort(arr, 10);
//	printf("Sorted array:");
//	print(arr, 10);
//	scanf("%d", &key);
//	int z=binary_search(arr, 10,key);
//	if (z == -1)
//	{
//		printf("%d Not be found!", key);
//	}
//	else
//	{
//		printf("m=%d,index=%d", key, z);
//	}
//	return 0;
//}

//#define N 40
//int main()
//{
//	float arr[N] = { 0 };
//	int n;
//	scanf("%d", &n);
//	int i = 0;
//	for (i = 0; i < n; i++)
//	{
//		scanf("%f", &arr[i]);
//	}
//	float max = arr[0], min = arr[0], average, sum = 0;
//	for (i = 0; i < n; i++)
//	{
//		if (max < arr[i])
//		{
//			max = arr[i];
//		}
//		if (min > arr[i])
//		{
//			min = arr[i];
//		}
//		sum += arr[i];
//	}
//	average = sum / n;
//	int count = 0;
//	for (i = 0; i < n; i++)
//	{
//		if (arr[i] >= average)
//		{
//			count++;
//		}
//	}
//	printf("最高分：%.2lf\n", max);
//	printf("最低分：%.2lf\n", min);
//	printf("平均分：%.2lf\n", average);
//	printf("高于等于平均分的人数：%d\n", count);
//	return 0;
//}

//void print_sys(int num, int sys)
//{
//	if (num)
//	{
//		printf("%d",num%sys);
//	}
//	else
//	{
//		printf("%d", num % sys);
//		return print_sys(num / sys, sys);
//	}
//
//}
//int main()
//{
//	int num = 0;
//	int sys = 0;
//	scanf("%d，%d", &num, &sys);
//	print_sys(num, sys);
//	return 0;
//}

//#include <iostream>
//#include <cstdio>
//#include<string>
//#include <utility>
//using namespace std;
////test 9（高精度减法）
//int main()
//{
//	string s1, s2;
//	int a1[200] = { 0 };
//	int a2[200] = { 0 };
//	int a3[200] = { 0 };
//	char flag = '+';
//	getline(cin, s1);
//	getline(cin, s2);
//	if (s1.size() < s2.size() || s1.size() == s2.size() && s1 < s2)
//	{
//		swap(s1, s2);
//		flag = '-';
//	}
//	int i = 0;
//	for (i = 0; i < s1.size(); i++)
//	{
//		a1[s1.size() - 1 - i] = s1[i]-'0';
//	}
//	for (i = 0; i < s2.size(); i++)
//	{
//		a2[s2.size() - 1 - i] = s2[i]-'0';
//	}
//	int len = s1.size();
//	if (len < s2.size())
//	{
//		len = s2.size();
//	}
//	for (i = 0; i < len; i++)
//	{
//		if (a1[i] < a2[i])
//		{
//			a1[i] += 10;
//			a1[i + 1] -= 1;
//		}
//		a3[i] = a1[i] - a2[i];
//	}
//	//对下表的寻找
//	int index = 0;
//	for (i = s1.size() - 1; i >= 0; i--)
//	{
//		if (a3[i] != 0)
//		{
//			index = i;
//			break;
//		}
//	}
//	//打印
//	if (flag != '+')
//		cout << flag;
//	for (i = index; i >= 0; i--)
//	{
//		cout << a3[i];
//	}
//
//	return 0;
//}




//
//char* my_strcpy(char* str1, const char* str2,int num)
//{
//	char* ret = str1;
//	assert(str1 != NULL);
//	while (num--)
//	{
//		if (*str2)
//		{
//			*str1 = *str2;
//			str1++;
//			str2++;
//		}
//		else
//		{
//			*str1 = '\0';
//			str1++;
//		}
//		
//	}
//	return ret;
//}
//int main()
//{
//	char arr1[50] = "abcdefxxxxxx";
//	char arr2[] = "hijk";
//	printf("%s\n", my_strcpy(arr1, arr2,6));
//	return 0;
//}



//
//char* my_strcat(char* str1, const char* str2,int num)
//{
//	char* ret = str1;
//	assert(str1 != NULL);
//	while (*str1)
//	{
//		str1++;
//	}
//	while (num--)
//	{
//		if (*str2 == 0)
//		{
//			*(++str1) = *(++str2);
//			break;
//		}
//		*str1++ = *str2++;
//	}
//	*str1 = '\0';
//
//	return ret;
//}
//int main()
//{
//	char arr1[50] = "abcdefxxxxxx";
//	char arr3[50] = "abcdefxxxxxx";
//
//	char arr2[] = "hijk";
//	printf("%s\n", my_strcat(arr1, arr2,1));
//	printf("%s\n", my_strcat(arr3, arr2, 20));
//
//	return 0;
//}
//void* my_memcpy(void* dest, const void* src, size_t num)
//{
//	assert(dest && src);
//	void* ret = dest;
//	while (num--)
//	{
//		*(char*)dest = *(char*)src;
//		dest = (char*)dest+1;
//		src = (char*)src + 1;
//	}
//	return ret;
//}
//
//int main()
//{
//	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int arr2[10] = { 0 };
//	my_memcpy(arr1, arr2,20);
//	return 0;
//}


//void* my_memmove(void* dest, const void* src, size_t num)
//{
//	assert(dest && src);
//	void* ret = dest;
//	while (num--)
//	{
//		if (dest < src)
//		{
//			*(char*)dest = *(char*)src;
//			dest = (char*)dest + 1;
//			src = (char*)src + 1;
//		}
//		else
//		{
//			*((char*)dest + num) = *((char*)src + num);
//		}
//	}
//	return ret;
//}
//
//int main()
//{
//	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int arr2[10] = { 0 };
//	my_memmove(arr1+2, arr1, 20);
//	return 0;
//}


//0000 0001 0010 1100
//0000 0000 1100 1000

//int main()
//{
//	unsigned char a = 200;
//	unsigned char b = 100;
//	unsigned char c = 0;
//	c = a + b;
//	printf(" % d % d", a + b, c);
//	return 0;
//}


//-1
//原码1
//反码
//补码


//int main()
//{
//	int a = 0x11223344;
//	return 0;
//}

//int main()
//{
//	//1000 0001原码
//	//1111 1110反码
//	//1111 1111补码
//	char a = -1;
//	//1000 0001原码
//	//1111 1110反码
//	//1111 1111补码
//	signed char b = -1;
//	//1000 0001原码
//	//1111 1110反码
//	//1111 1111补码
//	unsigned char c = -1;
//	//a整形提升11111111 11111111 11111111 11111111->10000000 00000000 00000000 00000001
//	//b同上
//	//c整形提升00000000 00000000 00000000 11111111->00000000 00000000 00000000 11111111->255
//	printf("a=%d,b=%d,c=%d", a, b, c);
//	
//	return 0;
//}


////char 的范围是-128-127
//int main()
//{
//	//原码1...1000 0000
//	//反码1...0111 1111
//	//补码1...1000 0000
//	char a = -128;
//	//存进去1000 0000
//	
//	//提升11111111 11111111 11111111  10000000->
//	printf("%u\n", a);
//	return 0;
//}


//int main()
//{
//	char a = 128;
//	//原码00000000 00000000 00000000 00000000 10000000
//	//补码00000000 00000000 00000000 00000000 10000000
//
//	printf("%u\n", a);
//	return 0;
//}
//
//#include<string.h>
//#include <stdio.h>
//int main()
//{
//char a[1000];
//int i;
//for (i = 0; i < 1000; i++)
//{
//a[i] = -1 - i;
//}
//printf("%d",strlen(a));
//return 0;
//}

//#include <stdio.h>
////X86环境 ⼩端字节序
//int main()
//{
//	int a[4] = { 1, 2, 3, 4 };
//	int* ptr1 = (int*)(&a + 1);
//	int* ptr2 = (int*)((int)a + 1);
//	printf("%x,%x", ptr1[-1], *ptr2);
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	int n = 9;
//	float* pFloat = (float*)&n;
//	printf("n的值为：%d\n", n);
//	printf("*pFloat的值为：%f\n", *pFloat);
//	*pFloat = 9.0;
//	printf("n的值为：%d\n", n);
//	printf("*pFloat的值为：%f\n", *pFloat);
//	return 0;
//}
//
//struct A
//{
//	int _a : 2;
//	int _b : 5;
//	int _c : 10;
//	int _d : 30;
//};
//int main()
//{
//	printf("%d\n", sizeof(struct A));
//	return 0;
//}